<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

</body>
</html>
<script>
    // Object.getPrototypeOf方法返回参数对象的原型。这是获取原型对象的标准方法
   /* var F = function () {};
    var f =new F();
    Object.getPrototypeOf(f) === F.prototype;
    console.log( Object.getPrototypeOf(f) === F.prototype);*/
    /*console.log(Object.getPrototypeOf({}) === Object.prototype);*/
    /*console.log(Object.getPrototypeOf(Object.prototype) === null);*/
   /* function f(){}
    console.log(Object.getPrototypeOf(f) === Function.prototype)*/

   // 方法将对象a的原型，设置为对象b，因此a可以共享b的属性
   /* var a = {};
    var b = {x:1,name:"zhangsan"};
    Object.setPrototypeOf(a,b);
    console.log(Object.getPrototypeOf(a) === b);
    console.log(a.name)*/

    // new命令可以使用Object.setPrototypeOf方法模拟。
  /*  var F = function () {
        this.foo = "aaa";
    };
    var f = new F();
    //等同于
    var f = Object.setPrototypeOf({},F.prototype);
    console.log(f);
    // F.call();
    console.log(F.call(f));*/

    // Object.create()
   /* // 接受一个对象作为参数，然后以它为原型，返回一个实例对象。该实例完全继承原型对象的属性。
    //原型对象
    var A = {
        print:function () {
            console.log("hello word");
        }
    };
    //实例对象
    var B = Object.create(A);
    console.log(Object.getPrototypeOf(B) === A);//true
    console.log(B.print());//hello word
    console.log(B.print === A.print);//true*/
    // Object.create()方法可以用下面的代码代替。
    // console.log(typeof Object.create);
  /*  if (typeof Object.create !== "function"){
        Object.create = function(obj){
            function F() {}
            F.prototype = obj;
            return new F();
        };
    }*/
    //下面三种方式生成的新对象是等价的
    // var obj1 = Object.create({});
    // var obj2 = Object.create(Object.prototype);
    // var obj3 = new Object();
    // console.log(obj1);
    // console.log(obj2);
    // console.log(obj3);

   //生成一个不继承任何属性 将Object.create()的参数设为null
    /*var obj = Object.create(null);
    obj.valueOf();//不具备一些定义在Object.prototype对象上面的属性，比如valueOf()方法
    console.log(obj.valueOf())*/  //必须提供对象原型，即参数不能为空，或者不是对象，否则会报错

   /* Object.create();
    console.log(console.log(123));*/

    // Object.create()方法生成的新对象，动态继承了原型。在原型上添加或修改任何方法，会立刻反映在新对象之上
    /*var obj1 = {p:1};
    var obj2 = Object.create(obj1);
    obj1.p = 2;
    console.log(obj1)
    console.log(obj2.p)*/    //修改对象原型obj1会影响到实例对象obj2

    // Object.create()方法还可以接受第二个参数
    /*var obj = Object.create({},{
        p1:{
            value:123,//属性值
            enumerable:true,//是否可枚举
            configurable:true,//是否可被delete删除
            writable:true,//是否可写
        },
        p2:{
            value:'abc',//属性值
            enumerable:true,//是否可枚举
            configurable:true,//是否可被delete删除
            writable:true,//是否可写
        }
    });
    console.log(obj)
    //等同于
    var obj = Object.create({});
    obj.p1 = 123;
    obj.p2 = "abc";*/

    // Object.create()方法生成的对象，继承了它的原型对象的构造函数
  /*  function A() {}
    var a = new A();
    var b = Object.create(a);
    b.constructor === A;
    b instanceof A;   //上面代码中，b对象的原型是a对象，因此继承了a对象的构造函数A
    console.log(b.constructor === A);//true
    console.log(b instanceof A);//true*/

    //实例对象的isPrototypeOf方法，用来判断该对象是否为参数对象的原型
   /* var p1 = {};
    var p2 = Object.create(p1);
    var p3 = Object.getPrototypeOf(p1);
    console.log(p2.isPrototypeOf(p2))*/


   //Object.getOwnPropertyNames方法返回一个数组，成员是参数对象本身的所有属性的键名
    //不包含继承的属性键名
/*
    var obj1 = {
        name : "wang"
    };
    var x = Object.getOwnPropertyNames(obj1);
    console.log(x)*/

</script>